home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / logging / Log.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  6.4 KB  |  224 lines
  1. package mx.logging
  2. {
  3.    import mx.core.mx_internal;
  4.    import mx.logging.errors.InvalidCategoryError;
  5.    import mx.resources.IResourceManager;
  6.    import mx.resources.ResourceManager;
  7.    
  8.    use namespace mx_internal;
  9.    
  10.    public class Log
  11.    {
  12.       private static var _resourceManager:IResourceManager;
  13.       
  14.       private static var _loggers:Array;
  15.       
  16.       mx_internal static const VERSION:String = "3.2.0.3958";
  17.       
  18.       private static var NONE:int = int.MAX_VALUE;
  19.       
  20.       private static var _targetLevel:int = NONE;
  21.       
  22.       private static var _targets:Array = [];
  23.       
  24.       public function Log()
  25.       {
  26.          super();
  27.       }
  28.       
  29.       private static function categoryMatchInFilterList(param1:String, param2:Array) : Boolean
  30.       {
  31.          var _loc4_:String = null;
  32.          var _loc3_:Boolean = false;
  33.          var _loc5_:int = -1;
  34.          var _loc6_:uint = 0;
  35.          while(_loc6_ < param2.length)
  36.          {
  37.             _loc4_ = param2[_loc6_];
  38.             _loc5_ = int(_loc4_.indexOf("*"));
  39.             if(_loc5_ == 0)
  40.             {
  41.                return true;
  42.             }
  43.             _loc5_ = param1.length;
  44.             _loc5_ = _loc5_ < 0 ? (_loc5_) : _loc5_ - 1;
  45.             if(param1.substring(0,_loc5_) == _loc4_.substring(0,_loc5_))
  46.             {
  47.                return true;
  48.             }
  49.             _loc6_++;
  50.          }
  51.          return false;
  52.       }
  53.       
  54.       public static function flush() : void
  55.       {
  56.          _loggers = [];
  57.          _targets = [];
  58.          _targetLevel = NONE;
  59.       }
  60.       
  61.       public static function isDebug() : Boolean
  62.       {
  63.          return _targetLevel <= LogEventLevel.DEBUG ? true : false;
  64.       }
  65.       
  66.       public static function getLogger(param1:String) : ILogger
  67.       {
  68.          var _loc3_:ILoggingTarget = null;
  69.          checkCategory(param1);
  70.          if(!_loggers)
  71.          {
  72.             _loggers = [];
  73.          }
  74.          var _loc2_:ILogger = _loggers[param1];
  75.          if(_loc2_ == null)
  76.          {
  77.             _loc2_ = new LogLogger(param1);
  78.             _loggers[param1] = _loc2_;
  79.          }
  80.          var _loc4_:int = 0;
  81.          while(_loc4_ < _targets.length)
  82.          {
  83.             _loc3_ = ILoggingTarget(_targets[_loc4_]);
  84.             if(categoryMatchInFilterList(param1,_loc3_.filters))
  85.             {
  86.                _loc3_.addLogger(_loc2_);
  87.             }
  88.             _loc4_++;
  89.          }
  90.          return _loc2_;
  91.       }
  92.       
  93.       public static function isWarn() : Boolean
  94.       {
  95.          return _targetLevel <= LogEventLevel.WARN ? true : false;
  96.       }
  97.       
  98.       public static function addTarget(param1:ILoggingTarget) : void
  99.       {
  100.          var _loc2_:Array = null;
  101.          var _loc3_:ILogger = null;
  102.          var _loc4_:String = null;
  103.          var _loc5_:String = null;
  104.          if(param1)
  105.          {
  106.             _loc2_ = param1.filters;
  107.             for(_loc4_ in _loggers)
  108.             {
  109.                if(categoryMatchInFilterList(_loc4_,_loc2_))
  110.                {
  111.                   param1.addLogger(ILogger(_loggers[_loc4_]));
  112.                }
  113.             }
  114.             _targets.push(param1);
  115.             if(_targetLevel == NONE)
  116.             {
  117.                _targetLevel = param1.level;
  118.             }
  119.             else if(param1.level < _targetLevel)
  120.             {
  121.                _targetLevel = param1.level;
  122.             }
  123.             return;
  124.          }
  125.          _loc5_ = resourceManager.getString("logging","invalidTarget");
  126.          throw new ArgumentError(_loc5_);
  127.       }
  128.       
  129.       public static function hasIllegalCharacters(param1:String) : Boolean
  130.       {
  131.          return param1.search(/[\[\]\~\$\^\&\\(\)\{\}\+\?\/=`!@#%,:;'"<>\s]/) != -1;
  132.       }
  133.       
  134.       private static function checkCategory(param1:String) : void
  135.       {
  136.          var _loc2_:String = null;
  137.          if(param1 == null || param1.length == 0)
  138.          {
  139.             _loc2_ = resourceManager.getString("logging","invalidLen");
  140.             throw new InvalidCategoryError(_loc2_);
  141.          }
  142.          if(hasIllegalCharacters(param1) || param1.indexOf("*") != -1)
  143.          {
  144.             _loc2_ = resourceManager.getString("logging","invalidChars");
  145.             throw new InvalidCategoryError(_loc2_);
  146.          }
  147.       }
  148.       
  149.       private static function resetTargetLevel() : void
  150.       {
  151.          var _loc1_:int = NONE;
  152.          var _loc2_:int = 0;
  153.          while(_loc2_ < _targets.length)
  154.          {
  155.             if(_loc1_ == NONE || _targets[_loc2_].level < _loc1_)
  156.             {
  157.                _loc1_ = int(_targets[_loc2_].level);
  158.             }
  159.             _loc2_++;
  160.          }
  161.          _targetLevel = _loc1_;
  162.       }
  163.       
  164.       public static function removeTarget(param1:ILoggingTarget) : void
  165.       {
  166.          var _loc2_:Array = null;
  167.          var _loc3_:ILogger = null;
  168.          var _loc4_:String = null;
  169.          var _loc5_:int = 0;
  170.          var _loc6_:String = null;
  171.          if(param1)
  172.          {
  173.             _loc2_ = param1.filters;
  174.             for(_loc4_ in _loggers)
  175.             {
  176.                if(categoryMatchInFilterList(_loc4_,_loc2_))
  177.                {
  178.                   param1.removeLogger(ILogger(_loggers[_loc4_]));
  179.                }
  180.             }
  181.             _loc5_ = 0;
  182.             while(_loc5_ < _targets.length)
  183.             {
  184.                if(param1 == _targets[_loc5_])
  185.                {
  186.                   _targets.splice(_loc5_,1);
  187.                   _loc5_--;
  188.                }
  189.                _loc5_++;
  190.             }
  191.             resetTargetLevel();
  192.             return;
  193.          }
  194.          _loc6_ = resourceManager.getString("logging","invalidTarget");
  195.          throw new ArgumentError(_loc6_);
  196.       }
  197.       
  198.       public static function isInfo() : Boolean
  199.       {
  200.          return _targetLevel <= LogEventLevel.INFO ? true : false;
  201.       }
  202.       
  203.       public static function isFatal() : Boolean
  204.       {
  205.          return _targetLevel <= LogEventLevel.FATAL ? true : false;
  206.       }
  207.       
  208.       public static function isError() : Boolean
  209.       {
  210.          return _targetLevel <= LogEventLevel.ERROR ? true : false;
  211.       }
  212.       
  213.       private static function get resourceManager() : IResourceManager
  214.       {
  215.          if(!_resourceManager)
  216.          {
  217.             _resourceManager = ResourceManager.getInstance();
  218.          }
  219.          return _resourceManager;
  220.       }
  221.    }
  222. }
  223.  
  224.